Chip 2007 January, February, March & April/Chip-Cover-CD-2007-02.iso/Pakiet bezpieczenstwa/mini Pentoo LiveCD 2006.1/mpentoo-2006.1.iso/livecd.squashfs/usr/lib/python2.4/tarfile.pyo

Python Compiled Bytecode | 2005-10-18 | 54KB | 1,959 lines

# Source Generated with Decompyle++
# File: in.pyo (Python 2.4)

'''Read from and write to tar format archives.
'''
__version__ = '$Revision: 1.21.2.5 $'
version = '0.6.4'
__author__ = 'Lars Gust\xe4bel ([e-mail])'
__date__ = '$Date: 2005/08/27 10:08:21 $'
__cvsid__ = '$Id: tarfile.py,v 1.21.2.5 2005/08/27 10:08:21 loewis Exp $'
__credits__ = 'Gustavo Niemeyer, Niels Gust\xe4bel, Richard Townsend.'
import sys
import os
import shutil
import stat
import errno
import time
import struct
if sys.platform == 'mac':
    raise ImportError, 'tarfile does not work for platform==mac'


try:
    import grp
    import pwd
except ImportError:
    grp = pwd = None

__all__ = [
    'TarFile',
    'TarInfo',
    'is_tarfile',
    'TarError']
NUL = '\x00'
BLOCKSIZE = 512
RECORDSIZE = BLOCKSIZE * 20
MAGIC = 'ustar'
VERSION = '00'
LENGTH_NAME = 100
LENGTH_LINK = 100
LENGTH_PREFIX = 155
MAXSIZE_MEMBER = 0x1FFFFFFFFL
REGTYPE = '0'
AREGTYPE = '\x00'
LNKTYPE = '1'
SYMTYPE = '2'
CHRTYPE = '3'
BLKTYPE = '4'
DIRTYPE = '5'
FIFOTYPE = '6'
CONTTYPE = '7'
GNUTYPE_LONGNAME = 'L'
GNUTYPE_LONGLINK = 'K'
GNUTYPE_SPARSE = 'S'
SUPPORTED_TYPES = (REGTYPE, AREGTYPE, LNKTYPE, SYMTYPE, DIRTYPE, FIFOTYPE, CONTTYPE, CHRTYPE, BLKTYPE, GNUTYPE_LONGNAME, GNUTYPE_LONGLINK, GNUTYPE_SPARSE)
REGULAR_TYPES = (REGTYPE, AREGTYPE, CONTTYPE, GNUTYPE_SPARSE)
S_IFLNK = 40960
S_IFREG = 32768
S_IFBLK = 24576
S_IFDIR = 16384
S_IFCHR = 8192
S_IFIFO = 4096
TSUID = 2048
TSGID = 1024
TSVTX = 512
TUREAD = 256
TUWRITE = 128
TUEXEC = 64
TGREAD = 32
TGWRITE = 16
TGEXEC = 8
TOREAD = 4
TOWRITE = 2
TOEXEC = 1

def nts(s):
    '''Convert a null-terminated string buffer to a python string.
    '''
    return s.rstrip(NUL)


def calc_chksum(buf):
    """Calculate the checksum for a member's header. It's a simple addition
       of all bytes, treating the chksum field as if filled with spaces.
       buf is a 512 byte long string buffer which holds the header.
    """
    chk = 256
    for c in buf[:148]:
        chk += ord(c)

    for c in buf[156:]:
        chk += ord(c)

    return chk


def copyfileobj(src, dst, length = None):
    '''Copy length bytes from fileobj src to fileobj dst.
       If length is None, copy the entire content.
    '''
    if length == 0:
        return None

    if length is None:
        shutil.copyfileobj(src, dst)
        return None

    BUFSIZE = 16 * 1024
    (blocks, remainder) = divmod(length, BUFSIZE)
    for b in xrange(blocks):
        buf = src.read(BUFSIZE)
        if len(buf) < BUFSIZE:
            raise IOError, 'end of file reached'

        dst.write(buf)

    if remainder != 0:
        buf = src.read(remainder)
        if len(buf) < remainder:
            raise IOError, 'end of file reached'

        dst.write(buf)


filemode_table = (((S_IFLNK, 'l'), (S_IFREG, '-'), (S_IFBLK, 'b'), (S_IFDIR, 'd'), (S_IFCHR, 'c'), (S_IFIFO, 'p')), ((TUREAD, 'r'),), ((TUWRITE, 'w'),), ((TUEXEC | TSUID, 's'), (TSUID, 'S'), (TUEXEC, 'x')), ((TGREAD, 'r'),), ((TGWRITE, 'w'),), ((TGEXEC | TSGID, 's'), (TSGID, 'S'), (TGEXEC, 'x')), ((TOREAD, 'r'),), ((TOWRITE, 'w'),), ((TOEXEC | TSVTX, 't'), (TSVTX, 'T'), (TOEXEC, 'x')))

def filemode(mode):
    """Convert a file's mode to a string of the form
       -rwxrwxrwx.
       Used by TarFile.list()
    """
    perm = []
    for table in filemode_table:
        for bit, char in table:
            if mode & bit == bit:
                perm.append(char)
                break
                continue


    return ''.join(perm)

if os.sep != '/':

    normpath = lambda path: os.path.normpath(path).replace(os.sep, '/')
else:
    normpath = os.path.normpath

class TarError(Exception):
    '''Base exception.'''
    pass


class ExtractError(TarError):
    '''General exception for extract errors.'''
    pass


class ReadError(TarError):
    '''Exception for unreadble tar archives.'''
    pass


class CompressionError(TarError):
    '''Exception for unavailable compression methods.'''
    pass


class StreamError(TarError):
    '''Exception for unsupported operations on stream-like TarFiles.'''
    pass


class _LowLevelFile:
    '''Low-level file object. Supports reading and writing.
       It is used instead of a regular file object for streaming
       access.
    '''

    def __init__(self, name, mode):
        mode = {
            'r': os.O_RDONLY,
            'w': os.O_WRONLY | os.O_CREAT | os.O_TRUNC }[mode]
        if hasattr(os, 'O_BINARY'):
            mode |= os.O_BINARY

        self.fd = os.open(name, mode)


    def close(self):
        os.close(self.fd)


    def read(self, size):
        return os.read(self.fd, size)


    def write(self, s):
        os.write(self.fd, s)



class _Stream:
    '''Class that serves as an adapter between TarFile and
       a stream-like object.  The stream-like object only
       needs to have a read() or write() method and is accessed
       blockwise.  Use of gzip or bzip2 compression is possible.
       A stream-like object could be for example: sys.stdin,
       sys.stdout, a socket, a tape device etc.

       _Stream is intended to be used only internally.
    '''

    def __init__(self, name, mode, type, fileobj, bufsize):
        '''Construct a _Stream object.
        '''
        self._extfileobj = True
        if fileobj is None:
            fileobj = _LowLevelFile(name, mode)
            self._extfileobj = False

        if not name:
            pass
        self.name = ''
        self.mode = mode
        self.type = type
        self.fileobj = fileobj
        self.bufsize = bufsize
        self.buf = ''
        self.pos = 0x0L
        self.closed = False
        if type == 'gz':

            try:
                import zlib as zlib
            except ImportError:
                raise CompressionError, 'zlib module is not available'

            self.zlib = zlib
            self.crc = zlib.crc32('')
            if mode == 'r':
                self._init_read_gz()
            else:
                self._init_write_gz()

        if type == 'bz2':

            try:
                import bz2
            except ImportError:
                raise CompressionError, 'bz2 module is not available'

            if mode == 'r':
                self.dbuf = ''
                self.cmp = bz2.BZ2Decompressor()
            else:
                self.cmp = bz2.BZ2Compressor()



    def __del__(self):
        if not self.closed:
            self.close()



    def _init_write_gz(self):
        '''Initialize for writing with gzip compression.
        '''
        self.cmp = self.zlib.compressobj(9, self.zlib.DEFLATED, -(self.zlib.MAX_WBITS), self.zlib.DEF_MEM_LEVEL, 0)
        timestamp = struct.pack('<L', long(time.time()))
        self._Stream__write('\x1f\x8b\x08\x08%s\x02\xff' % timestamp)
        if self.name.endswith('.gz'):
            self.name = self.name[:-3]

        self._Stream__write(self.name + NUL)


    def write(self, s):
        '''Write string s to the stream.
        '''
        if self.type == 'gz':
            self.crc = self.zlib.crc32(s, self.crc)

        self.pos += len(s)
        if self.type != 'tar':
            s = self.cmp.compress(s)

        self._Stream__write(s)


    def _Stream__write(self, s):
        '''Write string s to the stream if a whole new block
           is ready to be written.
        '''
        self.buf += s
        while len(self.buf) > self.bufsize:
            self.fileobj.write(self.buf[:self.bufsize])
            self.buf = self.buf[self.bufsize:]
            continue
            self


    def close(self):
        '''Close the _Stream object. No operation should be
           done on it afterwards.
        '''
        if self.closed:
            return None

        if self.mode == 'w' and self.type != 'tar':
            self.buf += self.cmp.flush()

        if self.mode == 'w' and self.buf:
            self.fileobj.write(self.buf)
            self.buf = ''
            if self.type == 'gz':
                self.fileobj.write(struct.pack('<l', self.crc))
                self.fileobj.write(struct.pack('<L', self.pos & 0xFFFFFFFFL))


        if not self._extfileobj:
            self.fileobj.close()

        self.closed = True


    def _init_read_gz(self):
        '''Initialize for reading a gzip compressed fileobj.
        '''
        self.cmp = self.zlib.decompressobj(-(self.zlib.MAX_WBITS))
        self.dbuf = ''
        if self._Stream__read(2) != '\x1f\x8b':
            raise ReadError, 'not a gzip file'

        if self._Stream__read(1) != '\x08':
            raise CompressionError, 'unsupported compression method'

        flag = ord(self._Stream__read(1))
        self._Stream__read(6)
        if flag & 4:
            xlen = ord(self._Stream__read(1)) + 256 * ord(self._Stream__read(1))
            self.read(xlen)

        if flag & 8:
            while True:
                s = self._Stream__read(1)
                if not s or s == NUL:
                    break
                    continue

        if flag & 16:
            while True:
                s = self._Stream__read(1)
                if not s or s == NUL:
                    break
                    continue

        if flag & 2:
            self._Stream__read(2)



    def tell(self):
        """Return the stream's file pointer position.
        """
        return self.pos


    def seek(self, pos = 0):
        """Set the stream's file pointer to pos. Negative seeking
           is forbidden.
        """
        if pos - self.pos >= 0:
            (blocks, remainder) = divmod(pos - self.pos, self.bufsize)
            for i in xrange(blocks):
                self.read(self.bufsize)

            self.read(remainder)
        else:
            raise StreamError, 'seeking backwards is not allowed'
        return self.pos


    def read(self, size = None):
        '''Return the next size number of bytes from the stream.
           If size is not defined, return all bytes of the stream
           up to EOF.
        '''
        if size is None:
            t = []
            while True:
                buf = self._read(self.bufsize)
                if not buf:
                    break

                t.append(buf)
            buf = ''.join(t)
        else:
            buf = self._read(size)
        self.pos += len(buf)
        return buf


    def _read(self, size):
        '''Return size bytes from the stream.
        '''
        if self.type == 'tar':
            return self._Stream__read(size)

        c = len(self.dbuf)
        t = [
            self.dbuf]
        while c < size:
            buf = self._Stream__read(self.bufsize)
            if not buf:
                break

            buf = self.cmp.decompress(buf)
            t.append(buf)
            c += len(buf)
        t = ''.join(t)
        self.dbuf = t[size:]
        return t[:size]


    def _Stream__read(self, size):
        '''Return size bytes from stream. If internal buffer is empty,
           read another block from the stream.
        '''
        c = len(self.buf)
        t = [
            self.buf]
        while c < size:
            buf = self.fileobj.read(self.bufsize)
            if not buf:
                break

            t.append(buf)
            c += len(buf)
        t = ''.join(t)
        self.buf = t[size:]
        return t[:size]



class ExFileObject(object):
    '''File-like object for reading an archive member.
       Is returned by TarFile.extractfile(). Support for
       sparse files included.
    '''

    def __init__(self, tarfile, tarinfo):
        self.fileobj = tarfile.fileobj
        self.name = tarinfo.name
        self.mode = 'r'
        self.closed = False
        self.offset = tarinfo.offset_data
        self.size = tarinfo.size
        self.pos = 0x0L
        self.linebuffer = ''
        if tarinfo.issparse():
            self.sparse = tarinfo.sparse
            self.read = self._readsparse
        else:
            self.read = self._readnormal


    def __read(self, size):
        '''Overloadable read method.
        '''
        return self.fileobj.read(size)


    def readline(self, size = -1):
        '''Read a line with approx. size. If size is negative,
           read a whole line. readline() and read() must not
           be mixed up (!).
        '''
        if size < 0:
            size = sys.maxint

        nl = self.linebuffer.find('\n')
        if nl >= 0:
            nl = min(nl, size)
        else:
            size -= len(self.linebuffer)
            while nl < 0 and size > 0:
                buf = self.read(min(size, 100))
                if not buf:
                    break

                self.linebuffer += buf
                size -= len(buf)
                nl = self.linebuffer.find('\n')
                continue
                self
            if nl == -1:
                s = self.linebuffer
                self.linebuffer = ''
                return s

        buf = self.linebuffer[:nl]
        self.linebuffer = self.linebuffer[nl + 1:]
        while buf[-1:] == '\r':
            buf = buf[:-1]
        return buf + '\n'


    def readlines(self):
        '''Return a list with all (following) lines.
        '''
        result = []
        while True:
            line = self.readline()
            if not line:
                break

            result.append(line)
        return result


    def _readnormal(self, size = None):
        '''Read operation for regular files.
        '''
        if self.closed:
            raise ValueError, 'file is closed'

        self.fileobj.seek(self.offset + self.pos)
        bytesleft = self.size - self.pos
        if size is None:
            bytestoread = bytesleft
        else:
            bytestoread = min(size, bytesleft)
        self.pos += bytestoread
        return self._ExFileObject__read(bytestoread)


    def _readsparse(self, size = None):
        '''Read operation for sparse files.
        '''
        if self.closed:
            raise ValueError, 'file is closed'

        if size is None:
            size = self.size - self.pos

        data = []
        while size > 0:
            buf = self._readsparsesection(size)
            if not buf:
                break

            size -= len(buf)
            data.append(buf)
        return ''.join(data)


    def _readsparsesection(self, size):
        '''Read a single section of a sparse file.
        '''
        section = self.sparse.find(self.pos)
        if section is None:
            return ''

        toread = min(size, section.offset + section.size - self.pos)


    def tell(self):
        '''Return the current file position.
        '''
        return self.pos


    def seek(self, pos, whence = 0):
        '''Seek to a position in the file.
        '''
        self.linebuffer = ''
        if whence == 0:
            self.pos = min(max(pos, 0), self.size)

        if whence == 1:
            if pos < 0:
                self.pos = max(self.pos + pos, 0)
            else:
                self.pos = min(self.pos + pos, self.size)

        if whence == 2:
            self.pos = max(min(self.size + pos, self.size), 0)



    def close(self):
        '''Close the file object.
        '''
        self.closed = True



class TarInfo(object):
    '''Informational class which holds the details about an
       archive member given by a tar header block.
       TarInfo objects are returned by TarFile.getmember(),
       TarFile.getmembers() and TarFile.gettarinfo() and are
       usually created internally.
    '''

    def __init__(self, name = ''):
        '''Construct a TarInfo object. name is the optional name
           of the member.
        '''
        self.name = name
        self.mode = 438
        self.uid = 0
        self.gid = 0
        self.size = 0
        self.mtime = 0
        self.chksum = 0
        self.type = REGTYPE
        self.linkname = ''
        self.uname = 'user'
        self.gname = 'group'
        self.devmajor = 0
        self.devminor = 0
        self.prefix = ''
        self.offset = 0
        self.offset_data = 0


    def __repr__(self):
        return '<%s %r at %#x>' % (self.__class__.__name__, self.name, id(self))


    def frombuf(cls, buf):
        '''Construct a TarInfo object from a 512 byte string buffer.
        '''
        tarinfo = cls()
        tarinfo.name = nts(buf[0:100])
        tarinfo.mode = int(buf[100:108], 8)
        tarinfo.uid = int(buf[108:116], 8)
        tarinfo.gid = int(buf[116:124], 8)
        tarinfo.mtime = long(buf[136:148], 8)
        tarinfo.chksum = int(buf[148:156], 8)
        tarinfo.type = buf[156:157]
        tarinfo.linkname = nts(buf[157:257])
        tarinfo.uname = nts(buf[265:297])
        tarinfo.gname = nts(buf[297:329])

        try:
            tarinfo.devmajor = int(buf[329:337], 8)
            tarinfo.devminor = int(buf[337:345], 8)
        except ValueError:
            tarinfo if buf[124] != chr(128) else tarinfo
            tarinfo if buf[124] != chr(128) else tarinfo
            tarinfo.devmajor = tarinfo.devmajor = 0
        except:
            tarinfo if buf[124] != chr(128) else tarinfo

        tarinfo.prefix = buf[345:500]
        if tarinfo.type != GNUTYPE_SPARSE:
            tarinfo.name = normpath(os.path.join(nts(tarinfo.prefix), tarinfo.name))

        if tarinfo.isdir() and tarinfo.name[-1:] != '/':
            tarinfo.name += '/'

        return tarinfo

    frombuf = classmethod(frombuf)

    def tobuf(self):
        '''Return a tar header block as a 512 byte string.
        '''
        if self.size <= MAXSIZE_MEMBER:
            size = '%011o' % self.size
        else:
            s = self.size
            size = ''
            for i in range(11):
                size = chr(s & 255) + size
                s >>= 8

            size = chr(128) + size
        parts = []
        for value, fieldsize in ((self.name, 100), ('%07o' % (self.mode & 4095), 8), ('%07o' % self.uid, 8), ('%07o' % self.gid, 8), (size, 12), ('%011o' % self.mtime, 12), ('        ', 8), (self.type, 1), (self.linkname, 100), (MAGIC, 6), (VERSION, 2), (self.uname, 32), (self.gname, 32), ('%07o' % self.devmajor, 8), ('%07o' % self.devminor, 8), (self.prefix, 155)):
            l = len(value)
            parts.append(value[:fieldsize] + (fieldsize - l) * NUL)

        buf = ''.join(parts)
        chksum = calc_chksum(buf)
        buf = buf[:148] + '%06o\x00' % chksum + buf[155:]
        buf += (BLOCKSIZE - len(buf)) * NUL
        self.buf = buf
        return buf


    def isreg(self):
        return self.type in REGULAR_TYPES


    def isfile(self):
        return self.isreg()


    def isdir(self):
        return self.type == DIRTYPE


    def issym(self):
        return self.type == SYMTYPE


    def islnk(self):
        return self.type == LNKTYPE


    def ischr(self):
        return self.type == CHRTYPE


    def isblk(self):
        return self.type == BLKTYPE


    def isfifo(self):
        return self.type == FIFOTYPE


    def issparse(self):
        return self.type == GNUTYPE_SPARSE


    def isdev(self):
        return self.type in (CHRTYPE, BLKTYPE, FIFOTYPE)



class TarFile(object):
    '''The TarFile Class provides an interface to tar archives.
    '''
    debug = 0
    dereference = False
    ignore_zeros = False
    errorlevel = 0
    posix = False
    fileobject = ExFileObject

    def __init__(self, name = None, mode = 'r', fileobj = None):
        """Open an (uncompressed) tar archive `name'. `mode' is either 'r' to
           read from an existing archive, 'a' to append data to an existing
           file or 'w' to create a new file overwriting an existing one. `mode'
           defaults to 'r'.
           If `fileobj' is given, it is used for reading or writing data. If it
           can be determined, `mode' is overridden by `fileobj's mode.
           `fileobj' is not closed, when TarFile is closed.
        """
        self.name = name
        if len(mode) > 1 or mode not in 'raw':
            raise ValueError, "mode must be 'r', 'a' or 'w'"

        self._mode = mode
        self.mode = {
            'r': 'rb',
            'a': 'r+b',
            'w': 'wb' }[mode]
        if not fileobj:
            fileobj = file(self.name, self.mode)
            self._extfileobj = False
        elif self.name is None and hasattr(fileobj, 'name'):
            self.name = fileobj.name

        if hasattr(fileobj, 'mode'):
            self.mode = fileobj.mode

        self._extfileobj = True
        self.fileobj = fileobj
        self.closed = False
        self.members = []
        self._loaded = False
        self.offset = 0x0L
        self.inodes = { }
        if self._mode == 'r':
            self.firstmember = None
            self.firstmember = self.next()

        if self._mode == 'a':
            self.firstmember = None
            while True:

                try:
                    tarinfo = self.next()
                except ReadError:
                    self.fileobj.seek(0)
                    break

                if tarinfo is None:
                    self.fileobj.seek(-BLOCKSIZE, 1)
                    break
                    continue

        if self._mode in 'aw':
            self._loaded = True



    def open(cls, name = None, mode = 'r', fileobj = None, bufsize = 20 * 512):
        """Open a tar archive for reading, writing or appending. Return
           an appropriate TarFile class.

           mode:
           'r'          open for reading with transparent compression
           'r:'         open for reading exclusively uncompressed
           'r:gz'       open for reading with gzip compression
           'r:bz2'      open for reading with bzip2 compression
           'a' or 'a:'  open for appending
           'w' or 'w:'  open for writing without compression
           'w:gz'       open for writing with gzip compression
           'w:bz2'      open for writing with bzip2 compression
           'r|'         open an uncompressed stream of tar blocks for reading
           'r|gz'       open a gzip compressed stream of tar blocks
           'r|bz2'      open a bzip2 compressed stream of tar blocks
           'w|'         open an uncompressed stream for writing
           'w|gz'       open a gzip compressed stream for writing
           'w|bz2'      open a bzip2 compressed stream for writing
        """
        if not name and not fileobj:
            raise ValueError, 'nothing to open'

        if ':' in mode:
            (filemode, comptype) = mode.split(':', 1)
            if not filemode:
                pass
            filemode = 'r'
            if not comptype:
                pass
            comptype = 'tar'
            if comptype in cls.OPEN_METH:
                func = getattr(cls, cls.OPEN_METH[comptype])
            else:
                raise CompressionError, 'unknown compression type %r' % comptype
            return func(name, filemode, fileobj)
        elif '|' in mode:
            (filemode, comptype) = mode.split('|', 1)
            if not filemode:
                pass
            filemode = 'r'
            if not comptype:
                pass
            comptype = 'tar'
            if filemode not in 'rw':
                raise ValueError, "mode must be 'r' or 'w'"

            t = cls(name, filemode, _Stream(name, filemode, comptype, fileobj, bufsize))
            t._extfileobj = False
            return t
        elif mode == 'r':
            for comptype in cls.OPEN_METH:
                func = getattr(cls, cls.OPEN_METH[comptype])

                try:
                    return func(name, 'r', fileobj)
                continue
                except (ReadError, CompressionError):
                    continue
                    continue



            raise ReadError, 'file could not be opened successfully'
        elif mode in 'aw':
            return cls.taropen(name, mode, fileobj)

        raise ValueError, 'undiscernible mode'

    open = classmethod(open)

    def taropen(cls, name, mode = 'r', fileobj = None):
        '''Open uncompressed tar archive name for reading or writing.
        '''
        if len(mode) > 1 or mode not in 'raw':
            raise ValueError, "mode must be 'r', 'a' or 'w'"

        return cls(name, mode, fileobj)

    taropen = classmethod(taropen)

    def gzopen(cls, name, mode = 'r', fileobj = None, compresslevel = 9):
        '''Open gzip compressed tar archive name for reading or writing.
           Appending is not allowed.
        '''
        if len(mode) > 1 or mode not in 'rw':
            raise ValueError, "mode must be 'r' or 'w'"


        try:
            import gzip as gzip
            gzip.GzipFile
        except (ImportError, AttributeError):
            raise CompressionError, 'gzip module is not available'

        (pre, ext) = os.path.splitext(name)
        pre = os.path.basename(pre)
        if ext == '.tgz':
            ext = '.tar'

        if ext == '.gz':
            ext = ''

        tarname = pre + ext
        if fileobj is None:
            fileobj = file(name, mode + 'b')

        if mode != 'r':
            name = tarname


        try:
            t = cls.taropen(tarname, mode, gzip.GzipFile(name, mode, compresslevel, fileobj))
        except IOError:
            raise ReadError, 'not a gzip file'

        t._extfileobj = False
        return t

    gzopen = classmethod(gzopen)

    def bz2open(cls, name, mode = 'r', fileobj = None, compresslevel = 9):
        '''Open bzip2 compressed tar archive name for reading or writing.
           Appending is not allowed.
        '''
        if len(mode) > 1 or mode not in 'rw':
            raise ValueError, "mode must be 'r' or 'w'."


        try:
            import bz2
        except ImportError:
            raise CompressionError, 'bz2 module is not available'

        (pre, ext) = os.path.splitext(name)
        pre = os.path.basename(pre)
        if ext == '.tbz2':
            ext = '.tar'

        if ext == '.bz2':
            ext = ''

        tarname = pre + ext
        if fileobj is not None:
            raise ValueError, 'no support for external file objects'


        try:
            t = cls.taropen(tarname, mode, bz2.BZ2File(name, mode, compresslevel = compresslevel))
        except IOError:
            raise ReadError, 'not a bzip2 file'

        t._extfileobj = False
        return t

    bz2open = classmethod(bz2open)
    OPEN_METH = {
        'tar': 'taropen',
        'gz': 'gzopen',
        'bz2': 'bz2open' }

    def close(self):
        '''Close the TarFile. In write-mode, two finishing zero blocks are
           appended to the archive.
        '''
        if self.closed:
            return None

        if self._mode in 'aw':
            self.fileobj.write(NUL * BLOCKSIZE * 2)
            self.offset += BLOCKSIZE * 2
            (blocks, remainder) = divmod(self.offset, RECORDSIZE)
            if remainder > 0:
                self.fileobj.write(NUL * (RECORDSIZE - remainder))


        if not self._extfileobj:
            self.fileobj.close()

        self.closed = True


    def getmember(self, name):
        """Return a TarInfo object for member `name'. If `name' can not be
           found in the archive, KeyError is raised. If a member occurs more
           than once in the archive, its last occurence is assumed to be the
           most up-to-date version.
        """
        tarinfo = self._getmember(name)
        if tarinfo is None:
            raise KeyError, 'filename %r not found' % name

        return tarinfo


    def getmembers(self):
        '''Return the members of the archive as a list of TarInfo objects. The
           list has the same order as the members in the archive.
        '''
        self._check()
        if not self._loaded:
            self._load()

        return self.members


    def getnames(self):
        '''Return the members of the archive as a list of their names. It has
           the same order as the list returned by getmembers().
        '''
        return [ tarinfo.name for tarinfo in self.getmembers() ]


    def gettarinfo(self, name = None, arcname = None, fileobj = None):
        """Create a TarInfo object for either the file `name' or the file
           object `fileobj' (using os.fstat on its file descriptor). You can
           modify some of the TarInfo's attributes before you add it using
           addfile(). If given, `arcname' specifies an alternative name for the
           file in the archive.
        """
        self._check('aw')
        if fileobj is not None:
            name = fileobj.name

        if arcname is None:
            arcname = name

        arcname = normpath(arcname)
        (drv, arcname) = os.path.splitdrive(arcname)
        while arcname[0:1] == '/':
            arcname = arcname[1:]
        tarinfo = TarInfo()
        if fileobj is None:
            if hasattr(os, 'lstat') and not (self.dereference):
                statres = os.lstat(name)
            else:
                statres = os.stat(name)
        else:
            statres = os.fstat(fileobj.fileno())
        linkname = ''
        stmd = statres.st_mode
        if stat.S_ISREG(stmd):
            inode = (statres.st_ino, statres.st_dev)
            if inode in self.inodes and not (self.dereference):
                type = LNKTYPE
                linkname = self.inodes[inode]
            else:
                type = REGTYPE
                if inode[0]:
                    self.inodes[inode] = arcname

        elif stat.S_ISDIR(stmd):
            type = DIRTYPE
            if arcname[-1:] != '/':
                arcname += '/'

        elif stat.S_ISFIFO(stmd):
            type = FIFOTYPE
        elif stat.S_ISLNK(stmd):
            type = SYMTYPE
            linkname = os.readlink(name)
        elif stat.S_ISCHR(stmd):
            type = CHRTYPE
        elif stat.S_ISBLK(stmd):
            type = BLKTYPE
        else:
            return None
        tarinfo.name = arcname
        tarinfo.mode = stmd
        tarinfo.uid = statres.st_uid
        tarinfo.gid = statres.st_gid
        if stat.S_ISREG(stmd):
            tarinfo.size = statres.st_size
        else:
            tarinfo.size = 0x0L
        tarinfo.mtime = statres.st_mtime
        tarinfo.type = type
        tarinfo.linkname = linkname
        if pwd:

            try:
                tarinfo.uname = pwd.getpwuid(tarinfo.uid)[0]
            except KeyError:
                pass
            except:
                None<EXCEPTION MATCH>KeyError


        None<EXCEPTION MATCH>KeyError
        if grp:

            try:
                tarinfo.gname = grp.getgrgid(tarinfo.gid)[0]
            except KeyError:
                pass
            except:
                None<EXCEPTION MATCH>KeyError


        None<EXCEPTION MATCH>KeyError
        if type in (CHRTYPE, BLKTYPE):
            if hasattr(os, 'major') and hasattr(os, 'minor'):
                tarinfo.devmajor = os.major(statres.st_rdev)
                tarinfo.devminor = os.minor(statres.st_rdev)


        return tarinfo


    def list(self, verbose = True):
        """Print a table of contents to sys.stdout. If `verbose' is False, only
           the names of the members are printed. If it is True, an `ls -l'-like
           output is produced.
        """
        self._check()
        for tarinfo in self:
            if verbose:
                print filemode(tarinfo.mode), None % ('%s/%s', tarinfo.uid if not tarinfo.uname else tarinfo.gid),
                if tarinfo.ischr() or tarinfo.isblk():
                    print '%10s' % '%d,%d' % (tarinfo.devmajor, tarinfo.devminor),
                else:
                    print '%10d' % tarinfo.size,
                print '%d-%02d-%02d %02d:%02d:%02d' % time.localtime(tarinfo.mtime)[:6],

            print tarinfo.name,
            if verbose:
                if tarinfo.issym():
                    print '->', tarinfo.linkname,

                if tarinfo.islnk():
                    print 'link to', tarinfo.linkname,


            print



    def add(self, name, arcname = None, recursive = True):
        """Add the file `name' to the archive. `name' may be any type of file
           (directory, fifo, symbolic link, etc.). If given, `arcname'
           specifies an alternative name for the file in the archive.
           Directories are added recursively by default. This can be avoided by
           setting `recursive' to False.
        """
        self._check('aw')
        if arcname is None:
            arcname = name

        if self.name is not None and os.path.abspath(name) == os.path.abspath(self.name):
            self._dbg(2, 'tarfile: Skipped %r' % name)
            return None

        if name == '.':
            if recursive:
                if arcname == '.':
                    arcname = ''

                for f in os.listdir('.'):
                    self.add(f, os.path.join(arcname, f))


            return None

        self._dbg(1, name)
        tarinfo = self.gettarinfo(name, arcname)
        if tarinfo is None:
            self._dbg(1, 'tarfile: Unsupported type %r' % name)
            return None

        if tarinfo.isreg():
            f = file(name, 'rb')
            self.addfile(tarinfo, f)
            f.close()
        elif tarinfo.isdir():
            self.addfile(tarinfo)
            if recursive:
                for f in os.listdir(name):
                    self.add(os.path.join(name, f), os.path.join(arcname, f))


        else:
            self.addfile(tarinfo)


    def addfile(self, tarinfo, fileobj = None):
        """Add the TarInfo object `tarinfo' to the archive. If `fileobj' is
           given, tarinfo.size bytes are read from it and added to the archive.
           You can create TarInfo objects using gettarinfo().
           On Windows platforms, `fileobj' should always be opened with mode
           'rb' to avoid irritation about the file size.
        """
        self._check('aw')
        tarinfo.name = normpath(tarinfo.name)
        if tarinfo.isdir():
            tarinfo.name += '/'

        if tarinfo.linkname:
            tarinfo.linkname = normpath(tarinfo.linkname)

        if tarinfo.size > MAXSIZE_MEMBER:
            if self.posix:
                raise ValueError, 'file is too large (>= 8 GB)'
            else:
                self._dbg(2, 'tarfile: Created GNU tar largefile header')

        if len(tarinfo.linkname) > LENGTH_LINK:
            if self.posix:
                raise ValueError, 'linkname is too long (>%d)' % LENGTH_LINK
            else:
                self._create_gnulong(tarinfo.linkname, GNUTYPE_LONGLINK)
                tarinfo.linkname = tarinfo.linkname[:LENGTH_LINK - 1]
                self._dbg(2, 'tarfile: Created GNU tar extension LONGLINK')

        if len(tarinfo.name) > LENGTH_NAME:
            if self.posix:
                prefix = tarinfo.name[:LENGTH_PREFIX + 1]
                while prefix and prefix[-1] != '/':
                    prefix = prefix[:-1]
                name = tarinfo.name[len(prefix):]
                prefix = prefix[:-1]
                if not prefix or len(name) > LENGTH_NAME:
                    raise ValueError, 'name is too long (>%d)' % LENGTH_NAME

                tarinfo.name = name
                tarinfo.prefix = prefix
            else:
                self._create_gnulong(tarinfo.name, GNUTYPE_LONGNAME)
                tarinfo.name = tarinfo.name[:LENGTH_NAME - 1]
                self._dbg(2, 'tarfile: Created GNU tar extension LONGNAME')

        self.fileobj.write(tarinfo.tobuf())
        self.offset += BLOCKSIZE
        if fileobj is not None:
            copyfileobj(fileobj, self.fileobj, tarinfo.size)
            (blocks, remainder) = divmod(tarinfo.size, BLOCKSIZE)
            if remainder > 0:
                self.fileobj.write(NUL * (BLOCKSIZE - remainder))
                blocks += 1

            self.offset += blocks * BLOCKSIZE

        self.members.append(tarinfo)


    def extract(self, member, path = ''):
        """Extract a member from the archive to the current working directory,
           using its full name. Its file information is extracted as accurately
           as possible. `member' may be a filename or a TarInfo object. You can
           specify a different directory using `path'.
        """
        self._check('r')
        if isinstance(member, TarInfo):
            tarinfo = member
        else:
            tarinfo = self.getmember(member)
        if tarinfo.islnk():
            tarinfo._link_target = os.path.join(path, tarinfo.linkname)


        try:
            self._extract_member(tarinfo, os.path.join(path, tarinfo.name))
        except EnvironmentError:
            e = None
            if self.errorlevel > 0:
                raise
            elif e.filename is None:
                self._dbg(1, 'tarfile: %s' % e.strerror)
            else:
                self._dbg(1, 'tarfile: %s %r' % (e.strerror, e.filename))
        except ExtractError:
            e = None
            if self.errorlevel > 1:
                raise
            else:
                self._dbg(1, 'tarfile: %s' % e)
        except:
            self.errorlevel > 1



    def extractfile(self, member):
        """Extract a member from the archive as a file object. `member' may be
           a filename or a TarInfo object. If `member' is a regular file, a
           file-like object is returned. If `member' is a link, a file-like
           object is constructed from the link's target. If `member' is none of
           the above, None is returned.
           The file-like object is read-only and provides the following
           methods: read(), readline(), readlines(), seek() and tell()
        """
        self._check('r')
        if isinstance(member, TarInfo):
            tarinfo = member
        else:
            tarinfo = self.getmember(member)
        if tarinfo.isreg():
            return self.fileobject(self, tarinfo)
        elif tarinfo.type not in SUPPORTED_TYPES:
            return self.fileobject(self, tarinfo)
        elif tarinfo.islnk() or tarinfo.issym():
            if isinstance(self.fileobj, _Stream):
                raise StreamError, 'cannot extract (sym)link as file object'
            else:
                return self.extractfile(self._getmember(tarinfo.linkname, tarinfo))
        else:
            return None


    def _extract_member(self, tarinfo, targetpath):
        '''Extract the TarInfo object tarinfo to a physical
           file called targetpath.
        '''
        if targetpath[-1:] == '/':
            targetpath = targetpath[:-1]

        targetpath = os.path.normpath(targetpath)
        upperdirs = os.path.dirname(targetpath)
        if upperdirs and not os.path.exists(upperdirs):
            ti = TarInfo()
            ti.name = upperdirs
            ti.type = DIRTYPE
            ti.mode = 511
            ti.mtime = tarinfo.mtime
            ti.uid = tarinfo.uid
            ti.gid = tarinfo.gid
            ti.uname = tarinfo.uname
            ti.gname = tarinfo.gname

            try:
                self._extract_member(ti, ti.name)


        if tarinfo.islnk() or tarinfo.issym():
            self._dbg(1, '%s -> %s' % (tarinfo.name, tarinfo.linkname))
        else:
            self._dbg(1, tarinfo.name)
        if tarinfo.isreg():
            self.makefile(tarinfo, targetpath)
        elif tarinfo.isdir():
            self.makedir(tarinfo, targetpath)
        elif tarinfo.isfifo():
            self.makefifo(tarinfo, targetpath)
        elif tarinfo.ischr() or tarinfo.isblk():
            self.makedev(tarinfo, targetpath)
        elif tarinfo.islnk() or tarinfo.issym():
            self.makelink(tarinfo, targetpath)
        elif tarinfo.type not in SUPPORTED_TYPES:
            self.makeunknown(tarinfo, targetpath)
        else:
            self.makefile(tarinfo, targetpath)
        self.chown(tarinfo, targetpath)
        if not tarinfo.issym():
            self.chmod(tarinfo, targetpath)
            self.utime(tarinfo, targetpath)



    def makedir(self, tarinfo, targetpath):
        '''Make a directory called targetpath.
        '''

        try:
            os.mkdir(targetpath)
        except EnvironmentError:
            e = None
            if e.errno != errno.EEXIST:
                raise

        except:
            e.errno != errno.EEXIST



    def makefile(self, tarinfo, targetpath):
        '''Make a file called targetpath.
        '''
        source = self.extractfile(tarinfo)
        target = file(targetpath, 'wb')
        copyfileobj(source, target)
        source.close()
        target.close()


    def makeunknown(self, tarinfo, targetpath):
        '''Make a file from a TarInfo object with an unknown type
           at targetpath.
        '''
        self.makefile(tarinfo, targetpath)
        self._dbg(1, 'tarfile: Unknown file type %r, extracted as regular file.' % tarinfo.type)


    def makefifo(self, tarinfo, targetpath):
        '''Make a fifo called targetpath.
        '''
        if hasattr(os, 'mkfifo'):
            os.mkfifo(targetpath)
        else:
            raise ExtractError, 'fifo not supported by system'


    def makedev(self, tarinfo, targetpath):
        '''Make a character or block device called targetpath.
        '''
        if not hasattr(os, 'mknod') or not hasattr(os, 'makedev'):
            raise ExtractError, 'special devices not supported by system'

        mode = tarinfo.mode
        if tarinfo.isblk():
            mode |= stat.S_IFBLK
        else:
            mode |= stat.S_IFCHR
        os.mknod(targetpath, mode, os.makedev(tarinfo.devmajor, tarinfo.devminor))


    def makelink(self, tarinfo, targetpath):
        '''Make a (symbolic) link called targetpath. If it cannot be created
          (platform limitation), we try to make a copy of the referenced file
          instead of a link.
        '''
        linkpath = tarinfo.linkname

        try:
            if tarinfo.issym():
                os.symlink(linkpath, targetpath)
            else:
                os.link(tarinfo._link_target, targetpath)
        except AttributeError:
            if tarinfo.issym():
                linkpath = os.path.join(os.path.dirname(tarinfo.name), linkpath)
                linkpath = normpath(linkpath)


            try:
                self._extract_member(self.getmember(linkpath), targetpath)
            except (EnvironmentError, KeyError):
                e = None
                linkpath = os.path.normpath(linkpath)

                try:
                    shutil.copy2(linkpath, targetpath)
                except EnvironmentError:
                    e = None
                    raise IOError, 'link could not be created'
                except:
                    None<EXCEPTION MATCH>EnvironmentError


                None<EXCEPTION MATCH>EnvironmentError


            None<EXCEPTION MATCH>(EnvironmentError, KeyError)



    def chown(self, tarinfo, targetpath):
        '''Set owner of targetpath according to tarinfo.
        '''
        if pwd and hasattr(os, 'geteuid') and os.geteuid() == 0:

            try:
                g = grp.getgrnam(tarinfo.gname)[2]
            except KeyError:

                try:
                    g = grp.getgrgid(tarinfo.gid)[2]
                except KeyError:
                    g = os.getgid()
                except:
                    None<EXCEPTION MATCH>KeyError


                None<EXCEPTION MATCH>KeyError


            try:
                u = pwd.getpwnam(tarinfo.uname)[2]
            except KeyError:

                try:
                    u = pwd.getpwuid(tarinfo.uid)[2]
                except KeyError:
                    u = os.getuid()
                except:
                    None<EXCEPTION MATCH>KeyError


                None<EXCEPTION MATCH>KeyError


            try:
                if tarinfo.issym() and hasattr(os, 'lchown'):
                    os.lchown(targetpath, u, g)
                elif sys.platform != 'os2emx':
                    os.chown(targetpath, u, g)
            except EnvironmentError:
                e = None
                raise ExtractError, 'could not change owner'
            except:
                None<EXCEPTION MATCH>EnvironmentError


        None<EXCEPTION MATCH>EnvironmentError


    def chmod(self, tarinfo, targetpath):
        '''Set file permissions of targetpath according to tarinfo.
        '''
        if hasattr(os, 'chmod'):

            try:
                os.chmod(targetpath, tarinfo.mode)
            except EnvironmentError:
                e = None
                raise ExtractError, 'could not change mode'
            except:
                None<EXCEPTION MATCH>EnvironmentError


        None<EXCEPTION MATCH>EnvironmentError


    def utime(self, tarinfo, targetpath):
        '''Set modification time of targetpath according to tarinfo.
        '''
        if not hasattr(os, 'utime'):
            return None

        if sys.platform == 'win32' and tarinfo.isdir():
            return None


        try:
            os.utime(targetpath, (tarinfo.mtime, tarinfo.mtime))
        except EnvironmentError:
            e = None
            raise ExtractError, 'could not change modification time'



    def next(self):
        '''Return the next member of the archive as a TarInfo object, when
           TarFile is opened for reading. Return None if there is no more
           available.
        '''
        self._check('ra')
        if self.firstmember is not None:
            m = self.firstmember
            self.firstmember = None
            return m

        self.fileobj.seek(self.offset)
        while True:
            buf = self.fileobj.read(BLOCKSIZE)
            if not buf:
                return None


            try:
                tarinfo = TarInfo.frombuf(buf)
            except ValueError:
                if self.ignore_zeros:
                    if buf.count(NUL) == BLOCKSIZE:
                        adj = 'empty'
                    else:
                        adj = 'invalid'
                    self._dbg(2, '0x%X: %s block' % (self.offset, adj))
                    self.offset += BLOCKSIZE
                    continue
                elif self.offset == 0:
                    raise ReadError, 'empty, unreadable or compressed file'

                return None

            break
        if tarinfo.chksum != calc_chksum(buf):
            self._dbg(1, 'tarfile: Bad Checksum %r' % tarinfo.name)

        tarinfo.offset = self.offset
        self.offset += BLOCKSIZE
        if tarinfo.type in self.TYPE_METH:
            return self.TYPE_METH[tarinfo.type](self, tarinfo)

        tarinfo.offset_data = self.offset
        if tarinfo.isreg() or tarinfo.type not in SUPPORTED_TYPES:
            self.offset += self._block(tarinfo.size)

        if tarinfo.isreg() and tarinfo.name[:-1] == '/':
            tarinfo.type = DIRTYPE

        self.members.append(tarinfo)
        return tarinfo


    def proc_gnulong(self, tarinfo):
        '''Evaluate the blocks that hold a GNU longname
           or longlink member.
        '''
        buf = ''
        count = tarinfo.size
        while count > 0:
            block = self.fileobj.read(BLOCKSIZE)
            buf += block
            self.offset += BLOCKSIZE
            count -= BLOCKSIZE
            continue
            self
        next = self.next()
        next.offset = tarinfo.offset
        if tarinfo.type == GNUTYPE_LONGNAME:
            next.name = nts(buf)
        elif tarinfo.type == GNUTYPE_LONGLINK:
            next.linkname = nts(buf)

        return next


    def proc_sparse(self, tarinfo):
        '''Analyze a GNU sparse header plus extra headers.
        '''
        buf = tarinfo.tobuf()
        sp = _ringbuffer()
        pos = 386
        lastpos = 0x0L
        realpos = 0x0L
        for i in xrange(4):

            try:
                offset = int(buf[pos:pos + 12], 8)
                numbytes = int(buf[pos + 12:pos + 24], 8)
            except ValueError:
                break

            if offset > lastpos:
                sp.append(_hole(lastpos, offset - lastpos))

            sp.append(_data(offset, numbytes, realpos))
            realpos += numbytes
            lastpos = offset + numbytes
            pos += 24

        isextended = ord(buf[482])
        origsize = int(buf[483:495], 8)
        while isextended == 1:
            buf = self.fileobj.read(BLOCKSIZE)
            self.offset += BLOCKSIZE
            pos = 0
            for i in xrange(21):

                try:
                    offset = int(buf[pos:pos + 12], 8)
                    numbytes = int(buf[pos + 12:pos + 24], 8)
                except ValueError:
                    self
                    self
                    break
                except:
                    self

                if offset > lastpos:
                    sp.append(_hole(lastpos, offset - lastpos))

                sp.append(_data(offset, numbytes, realpos))
                realpos += numbytes
                lastpos = offset + numbytes
                pos += 24

            isextended = ord(buf[504])
        if lastpos < origsize:
            sp.append(_hole(lastpos, origsize - lastpos))

        tarinfo.sparse = sp
        tarinfo.offset_data = self.offset
        self.offset += self._block(tarinfo.size)
        tarinfo.size = origsize
        self.members.append(tarinfo)
        return tarinfo

    TYPE_METH = {
        GNUTYPE_LONGNAME: proc_gnulong,
        GNUTYPE_LONGLINK: proc_gnulong,
        GNUTYPE_SPARSE: proc_sparse }

    def _block(self, count):
        '''Round up a byte count by BLOCKSIZE and return it,
           e.g. _block(834) => 1024.
        '''
        (blocks, remainder) = divmod(count, BLOCKSIZE)
        if remainder:
            blocks += 1

        return blocks * BLOCKSIZE


    def _getmember(self, name, tarinfo = None):
        '''Find an archive member by name from bottom to top.
           If tarinfo is given, it is used as the starting point.
        '''
        members = self.getmembers()
        if tarinfo is None:
            end = len(members)
        else:
            end = members.index(tarinfo)
        for i in xrange(end - 1, -1, -1):
            if name == members[i].name:
                return members[i]
                continue



    def _load(self):
        '''Read through the entire archive file and look for readable
           members.
        '''
        while True:
            tarinfo = self.next()
            if tarinfo is None:
                break
                continue
        self._loaded = True


    def _check(self, mode = None):
        """Check if TarFile is still open, and if the operation's mode
           corresponds to TarFile's mode.
        """
        if self.closed:
            raise IOError, '%s is closed' % self.__class__.__name__

        if mode is not None and self._mode not in mode:
            raise IOError, 'bad operation for mode %r' % self._mode



    def __iter__(self):
        '''Provide an iterator object.
        '''
        if self._loaded:
            return iter(self.members)
        else:
            return TarIter(self)


    def _create_gnulong(self, name, type):
        '''Write a GNU longname/longlink member to the TarFile.
           It consists of an extended tar header, with the length
           of the longname as size, followed by data blocks,
           which contain the longname as a null terminated string.
        '''
        name += NUL
        tarinfo = TarInfo()
        tarinfo.name = '././@LongLink'
        tarinfo.type = type
        tarinfo.mode = 0
        tarinfo.size = len(name)
        self.fileobj.write(tarinfo.tobuf())
        self.offset += BLOCKSIZE
        self.fileobj.write(name)
        (blocks, remainder) = divmod(tarinfo.size, BLOCKSIZE)
        if remainder > 0:
            self.fileobj.write(NUL * (BLOCKSIZE - remainder))
            blocks += 1

        self.offset += blocks * BLOCKSIZE


    def _dbg(self, level, msg):
        '''Write debugging output to sys.stderr.
        '''
        if level <= self.debug:
            print >>sys.stderr, msg




class TarIter:
    '''Iterator Class.

       for tarinfo in TarFile(...):
           suite...
    '''

    def __init__(self, tarfile):
        '''Construct a TarIter object.
        '''
        self.tarfile = tarfile
        self.index = 0


    def __iter__(self):
        '''Return iterator object.
        '''
        return self


    def next(self):
        """Return the next item using TarFile's next() method.
           When all members have been read, set TarFile as _loaded.
        """
        if not self.tarfile._loaded:
            tarinfo = self.tarfile.next()
            if not tarinfo:
                self.tarfile._loaded = True
                raise StopIteration

        else:

            try:
                tarinfo = self.tarfile.members[self.index]
            except IndexError:
                raise StopIteration

        self.index += 1
        return tarinfo



class _section:
    '''Base class for _data and _hole.
    '''

    def __init__(self, offset, size):
        self.offset = offset
        self.size = size


    def __contains__(self, offset):
        return None if offset <= offset else offset < self.offset + self.size



class _data(_section):
    '''Represent a data section in a sparse file.
    '''

    def __init__(self, offset, size, realpos):
        _section.__init__(self, offset, size)
        self.realpos = realpos



class _hole(_section):
    '''Represent a hole section in a sparse file.
    '''
    pass


class _ringbuffer(list):
    '''Ringbuffer class which increases performance
       over a regular list.
    '''

    def __init__(self):
        self.idx = 0


    def find(self, offset):
        idx = self.idx
        while True:
            item = self[idx]
            if offset in item:
                break

            idx += 1
            if idx == len(self):
                idx = 0

            if idx == self.idx:
                return None
                continue
        self.idx = idx
        return item


TAR_PLAIN = 0
TAR_GZIPPED = 8

class TarFileCompat:
    """TarFile class compatible with standard module zipfile's
       ZipFile class.
    """

    def __init__(self, file, mode = 'r', compression = TAR_PLAIN):
        if compression == TAR_PLAIN:
            self.tarfile = TarFile.taropen(file, mode)
        elif compression == TAR_GZIPPED:
            self.tarfile = TarFile.gzopen(file, mode)
        else:
            raise ValueError, 'unknown compression constant'
        if mode[0:1] == 'r':
            members = self.tarfile.getmembers()
            for i in xrange(len(members)):
                m = members[i]
                m.filename = m.name
                m.file_size = m.size
                m.date_time = time.gmtime(m.mtime)[:6]




    def namelist(self):
        return map((lambda m: m.name), self.infolist())


    def infolist(self):
        return filter((lambda m: m.type in REGULAR_TYPES), self.tarfile.getmembers())


    def printdir(self):
        self.tarfile.list()


    def testzip(self):
        pass


    def getinfo(self, name):
        return self.tarfile.getmember(name)


    def read(self, name):
        return self.tarfile.extractfile(self.tarfile.getmember(name)).read()


    def write(self, filename, arcname = None, compress_type = None):
        self.tarfile.add(filename, arcname)


    def writestr(self, zinfo, bytes):
        import StringIO as StringIO
        import calendar as calendar
        zinfo.name = zinfo.filename
        zinfo.size = zinfo.file_size
        zinfo.mtime = calendar.timegm(zinfo.date_time)
        self.tarfile.addfile(zinfo, StringIO.StringIO(bytes))


    def close(self):
        self.tarfile.close()



def is_tarfile(name):
    '''Return True if name points to a tar archive that we
       are able to handle, else return False.
    '''

    try:
        t = open(name)
        t.close()
        return True
    except TarError:
        return False


open = TarFile.open